package com.feng.study.demo.juc;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * 四大函数式接口：
 *      Function<T,R> ：函数型接口
 *      Predicate：断言型接口，返回值boolean
 *      Supplier ：供给型接口
 *      Consumer：消费型接口
 *
 * 优点：
 * 代码简介，开发迅速
 * 方便函数式编程
 * 非常容易进行并行计算
 * Java引入Lambda，改善了集合操作（引入Stream API），并可以利用到Lambda表达式的延后性
 * 缺点：
 * 代码可读性差
 * 在非并行计算中，很多未必有传统的for性能高
 * 不容易进行调试
 */
public class FunctionalDemo {
    public static void main(String[] args) {

        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.forEach(System.out::println);
        list.stream()
                .sorted((o1,o2)->o2-o1)
                .forEach(System.out::println);

        // Function<T,R> ：函数型接口
        Function<String ,String> function = new Function<String,String>(){
            @Override
            public String apply(String s) {
                return s;
            }
        };
        System.out.println(function.apply("abs"));

        // Predicate：断言型接口，返回值boolean
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.isEmpty();
            }
        };
        System.out.println(predicate.test(""));

        // Consumer：消费型接口
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("hello world!");

        // Supplier ：供给型接口
        Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return 1024;
            }
        };
        System.out.println(supplier.get());
    }
}
